#
# Gramps - a GTK+/GNOME based genealogy program
#
# Adapted from Graphviz.py (now deprecated)
#    Copyright (C) 2000-2007  Donald N. Allingham
#    Copyright (C) 2005-2006  Eero Tamminen
#    Copyright (C) 2007-2008  Brian G. Matherly
#    Copyright (C) 2007       Johan Gonqvist <johan.gronqvist@gmail.com>
#    Contributions by Lorenzo Cappelletti <lorenzo.cappelletti@email.it>
#    Copyright (C) 2008       Stephane Charette <stephanecharette@gmail.com>
#    Copyright (C) 2009       Gary Burton
#    Contribution 2009 by     Bob Ham <rah@bash.sh>
#    Copyright (C) 2010       Jakim Friant
#    Copyright (C) 2013       Fedir Zinchuk <fedikw@gmail.com>
#    Copyright (C) 2013-2015  Paul Franklin
#    Copyright (C) 2015       Fabrice <fobrice@laposte.net>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#

"""
Create a relationship graph using Graphviz
"""

#------------------------------------------------------------------------
#
# python modules
#
#------------------------------------------------------------------------
from functools import partial

#------------------------------------------------------------------------
#
# Gramps modules
#
#------------------------------------------------------------------------
from gramps.gen.const import GRAMPS_LOCALE as glocale
_ = glocale.translation.sgettext
from gramps.gen.plug.menu import (BooleanOption, EnumeratedListOption,
                                  FilterOption, PersonOption, ColorOption)
from gramps.gen.plug.report import Report
from gramps.gen.plug.report import utils
from gramps.gen.plug.report import MenuReportOptions
from gramps.gen.plug.report import stdoptions
from gramps.gen.lib import ChildRefType, EventRoleType, EventType
from gramps.gen.utils.file import media_path_full, find_file
from gramps.gen.utils.thumbnails import get_thumbnail_path
from gramps.gen.relationship import get_relationship_calculator
from gramps.gen.utils.db import (get_birth_or_fallback, get_death_or_fallback,
                                 find_parents)
from gramps.gen.display.place import displayer as _pd
from gramps.gen.proxy import CacheProxyDb
from gramps.gen.errors import ReportError

#------------------------------------------------------------------------
#
# Constant options items
#
#------------------------------------------------------------------------
_COLORS = [{'name' : _("B&W outline"),     'value' : 'outlined'},
           {'name' : _("Colored outline"), 'value' : 'colored'},
           {'name' : _("Color fill"),      'value' : 'filled'}]

_ARROWS = [{'name' : _("Descendants <- Ancestors"),  'value' : 'd'},
           {'name' : _("Descendants -> Ancestors"),  'value' : 'a'},
           {'name' : _("Descendants <-> Ancestors"), 'value' : 'da'},
           {'name' : _("Descendants - Ancestors"),   'value' : ''}]

#------------------------------------------------------------------------
#
# RelGraphReport class
#
#------------------------------------------------------------------------
class RelGraphReport(Report):

    def __init__(self, database, options, user):
        """
        Create RelGraphReport object that produces the report.

        The arguments are:

        database        - the Gramps database instance
        options         - instance of the Options class for this report
        user            - a gen.user.User() instance

        This report needs the following parameters (class variables)
        that come in the options class.

        filter     - Filter to be applied to the people of the database.
                     The option class carries its number, and the function
                     returning the list of filters.
        arrow      - Arrow styles for heads and tails.
        showfamily - Whether to show family nodes.
        inc_id     - Whether to include IDs.
        url        - Whether to include URLs.
        inclimg    - Include images or not
        imgpos     - Image position, above/beside name
        color      - Whether to use outline, colored outline or filled color
                     in graph
        color_males    - Colour to apply to males
        color_females  - Colour to apply to females
        color_unknown  - Colour to apply to unknown genders
        color_families - Colour to apply to families
        dashed         - Whether to use dashed lines for non-birth relationships
        use_roundedcorners - Whether to use rounded corners for females
        name_format    - Preferred format to display names
        incl_private   - Whether to include private data
        event_choice   - Whether to include dates and/or places
        occupation     - Whether to include occupations
        living_people - How to handle living people
        years_past_death - Consider as living this many years after death
        """
        Report.__init__(self, database, options, user)

        menu = options.menu
        get_option_by_name = options.menu.get_option_by_name
        get_value = lambda name: get_option_by_name(name).get_value()

        self.set_locale(menu.get_option_by_name('trans').get_value())

        stdoptions.run_date_format_option(self, menu)

        stdoptions.run_private_data_option(self, menu)
        stdoptions.run_living_people_option(self, menu, self._locale)
        self.database = CacheProxyDb(self.database)
        self._db = self.database

        self.includeid = get_value('inc_id')
        self.includeurl = get_value('url')
        self.includeimg = get_value('includeImages')
        self.imgpos = get_value('imageOnTheSide')
        self.use_roundedcorners = get_value('useroundedcorners')
        self.adoptionsdashed = get_value('dashed')
        self.show_families = get_value('showfamily')
        self.use_subgraphs = get_value('usesubgraphs')
        self.event_choice = get_value('event_choice')
        self.occupation = get_value('occupation')
        self.use_html_output = False

        self.colorize = get_value('color')
        color_males = get_value('colormales')
        color_females = get_value('colorfemales')
        color_unknown = get_value('colorunknown')
        color_families = get_value('colorfamilies')
        self.colors = {
            'male': color_males,
            'female': color_females,
            'unknown': color_unknown,
            'family': color_families
        }

        arrow_str = get_value('arrow')
        if 'd' in arrow_str:
            self.arrowheadstyle = 'normal'
        else:
            self.arrowheadstyle = 'none'
        if 'a' in arrow_str:
            self.arrowtailstyle = 'normal'
        else:
            self.arrowtailstyle = 'none'
        filter_option = get_option_by_name('filter')
        self._filter = filter_option.get_filter()

        stdoptions.run_name_format_option(self, menu)

        pid = get_value('pid')
        self.center_person = self._db.get_person_from_gramps_id(pid)
        if self.center_person is None:
            raise ReportError(_("Person %s is not in the Database") % pid)

        self.increlname = get_value('increlname')
        if self.increlname:
            self.rel_calc = get_relationship_calculator(reinit=True,
                                                        clocale=self._locale)

        if __debug__:
            self.advrelinfo = get_value('advrelinfo')
        else:
            self.advrelinfo = False

    def write_report(self):
        person_handles = self._filter.apply(self._db,
                                            self._db.iter_person_handles(),
                                            user=self._user)

        person_handles = self.sort_persons(person_handles)

        if len(person_handles) > 1:
            if self._user:
                self._user.begin_progress(_("Relationship Graph"),
                                          _("Generating report"),
                                          len(person_handles) * 2)
            self.add_persons_and_families(person_handles)
            self.add_child_links_to_families(person_handles)
            if self._user:
                self._user.end_progress()

    def sort_persons(self, person_handle_list):
        "sort persons by close relations"

        # first make a list of all persons who don't have any parents
        root_nodes = list()
        for person_handle in person_handle_list:
            person = self.database.get_person_from_handle(person_handle)
            has_parent = False
            for parent_handle in find_parents(self.database, person):
                if parent_handle not in person_handle_list:
                    continue
                has_parent = True
            if not has_parent:
                root_nodes.append(person_handle)

        # now start from all root nodes we found and traverse their trees
        outlist = list()
        p_done = set()
        for person_handle in root_nodes:
            todolist = list()
            todolist.append(person_handle)
            while len(todolist) > 0:
                # take the first person from todolist and do sanity check
                cur = todolist.pop(0)
                if cur in p_done:
                    continue
                if cur not in person_handle_list:
                    p_done.add(cur)
                    continue
                person = self.database.get_person_from_handle(cur)

                # first check whether both parents are added
                missing_parents = False
                for parent_handle in find_parents(self.database, person):
                    if not parent_handle or parent_handle in p_done:
                        continue
                    if parent_handle not in person_handle_list:
                        continue
                    todolist.insert(0, parent_handle)
                    missing_parents = True

                # if one of the parents is still missing, wait for them
                if missing_parents:
                    continue

                # add person to the sorted output
                outlist.append(cur)
                p_done.add(cur)

                # add all spouses and children to the todo list
                family_list = person.get_family_handle_list()
                for fam_handle in family_list:
                    family = self.database.get_family_from_handle(fam_handle)
                    if family is None:
                        continue
                    if (family.get_father_handle() and
                            family.get_father_handle() != cur):
                        todolist.insert(0, family.get_father_handle())
                    if (family.get_mother_handle() and
                            family.get_mother_handle() != cur):
                        todolist.insert(0, family.get_mother_handle())
                    for child_ref in family.get_child_ref_list():
                        todolist.append(child_ref.ref)

        # finally store the result
        assert len(person_handle_list) == len(outlist)
        return outlist

    def add_child_links_to_families(self, person_handles):
        """
        returns string of Graphviz edges linking parents to families or
        children
        """
        # Hash people in a dictionary for faster inclusion checking
        person_dict = dict([handle, 1] for handle in person_handles)

        for person_handle in person_handles:
            if self._user:
                self._user.step_progress()
            person = self._db.get_person_from_handle(person_handle)
            p_id = person.get_gramps_id()
            for fam_handle in person.get_parent_family_handle_list():
                family = self._db.get_family_from_handle(fam_handle)
                father_handle = family.get_father_handle()
                mother_handle = family.get_mother_handle()
                for child_ref in family.get_child_ref_list():
                    if child_ref.ref == person_handle:
                        frel = child_ref.frel
                        mrel = child_ref.mrel
                        break
                if (self.show_families and
                        ((father_handle and father_handle in person_dict) or
                         (mother_handle and mother_handle in person_dict))):
                    # Link to the family node if either parent is in graph
                    self.add_family_link(p_id, family, frel, mrel)
                else:
                    # Link to the parents' nodes directly, if they are in graph
                    if father_handle and father_handle in person_dict:
                        self.add_parent_link(p_id, father_handle, frel)
                    if mother_handle and mother_handle in person_dict:
                        self.add_parent_link(p_id, mother_handle, mrel)

    def add_family_link(self, p_id, family, frel, mrel):
        "Links the child to a family"
        style = 'solid'
        adopted = ((int(frel) != ChildRefType.BIRTH) or
                   (int(mrel) != ChildRefType.BIRTH))
        # If birth relation to father is NONE, meaning there is no father and
        # if birth relation to mother is BIRTH then solid line
        if (int(frel) == ChildRefType.NONE and
                int(mrel) == ChildRefType.BIRTH):
            adopted = False
        if adopted and self.adoptionsdashed:
            style = 'dotted'
        self.doc.add_link(family.get_gramps_id(), p_id, style,
                          self.arrowheadstyle, self.arrowtailstyle)

    def add_parent_link(self, p_id, parent_handle, rel):
        "Links the child to a parent"
        style = 'solid'
        if (int(rel) != ChildRefType.BIRTH) and self.adoptionsdashed:
            style = 'dotted'
        parent = self._db.get_person_from_handle(parent_handle)
        self.doc.add_link(parent.get_gramps_id(), p_id, style,
                          self.arrowheadstyle, self.arrowtailstyle)

    def add_persons_and_families(self, person_handles):
        "adds nodes for persons and their families"
        # variable to communicate with get_person_label
        self.use_html_output = False

        # The list of families for which we have output the node,
        # so we don't do it twice
        families_done = set()
        for person_handle in person_handles:
            if self._user:
                self._user.step_progress()
            # determine per person if we use HTML style label
            if self.includeimg:
                self.use_html_output = True
            person = self._db.get_person_from_handle(person_handle)
            if person is None:
                continue
            p_id = person.get_gramps_id()
            # Output the person's node
            label = self.get_person_label(person)
            (shape, style, color, fill) = self.get_gender_style(person)
            url = ""
            if self.includeurl:
                phan = person_handle
                dirpath = "ppl/%s/%s" % (phan[-1], phan[-2])
                dirpath = dirpath.lower()
                url = "%s/%s.html" % (dirpath, phan)

            self.doc.add_node(p_id, label, shape, color, style, fill, url)

            # Output families where person is a parent
            if self.show_families:
                family_list = person.get_family_handle_list()
                for fam_handle in family_list:
                    family = self._db.get_family_from_handle(fam_handle)
                    if family is None:
                        continue
                    if fam_handle not in families_done:
                        families_done.add(fam_handle)
                        self.__add_family(fam_handle)
                    # If subgraphs are not chosen then each parent is linked
                    # separately to the family. This gives Graphviz greater
                    # control over the layout of the whole graph but
                    # may leave spouses not positioned together.
                    if not self.use_subgraphs:
                        self.doc.add_link(p_id, family.get_gramps_id(), "",
                                          self.arrowheadstyle,
                                          self.arrowtailstyle)

    def __add_family(self, fam_handle):
        """Add a node for a family and optionally link the spouses to it"""
        fam = self._db.get_family_from_handle(fam_handle)
        if fam is None:
            return
        fam_id = fam.get_gramps_id()

        m_type = m_date = m_place = ""
        d_type = d_date = d_place = ""
        for event_ref in fam.get_event_ref_list():
            event = self._db.get_event_from_handle(event_ref.ref)
            if event is None:
                continue
            if (event.type == EventType.MARRIAGE and
                    (event_ref.get_role() == EventRoleType.FAMILY or
                     event_ref.get_role() == EventRoleType.PRIMARY)):
                m_type = event.type
                m_date = self.get_date_string(event)
                if not (self.event_choice == 3 and m_date):
                    m_place = self.get_place_string(event)
                break
            if (event.type == EventType.DIVORCE and
                    (event_ref.get_role() == EventRoleType.FAMILY or
                     event_ref.get_role() == EventRoleType.PRIMARY)):
                d_type = event.type
                d_date = self.get_date_string(event)
                if not (self.event_choice == 3 and d_date):
                    d_place = self.get_place_string(event)
                break

        labellines = list()
        if self.includeid == 2:
            # id on separate line
            labellines.append("(%s)" % fam_id)
        if self.event_choice == 7:
            if m_type:
                line = m_type.get_abbreviation()
                if m_date:
                    line += ' %s' % m_date
                if m_date and m_place:
                    labellines.append(line)
                    line = ''
                if m_place:
                    line += ' %s' % m_place
                labellines.append(line)
            if d_type:
                line = d_type.get_abbreviation()
                if d_date:
                    line += ' %s' % d_date
                if d_date and d_place:
                    labellines.append(line)
                    line = ''
                if d_place:
                    line += ' %s' % d_place
                labellines.append(line)
        else:
            if m_date:
                labellines.append("(%s)" % m_date)
            if m_place:
                labellines.append("(%s)" % m_place)

        label = "\\n".join(labellines)
        labellines = list()
        if self.includeid == 1:
            # id on same line
            labellines.append("(%s)" % fam_id)
        if len(label):
            labellines.append(label)
        label = ' '.join(labellines)

        color = ""
        fill = ""
        style = "solid"
        if self.colorize == 'colored':
            color = self.colors['family']
        elif self.colorize == 'filled':
            fill = self.colors['family']
            style = "filled"
        self.doc.add_node(fam_id, label, "ellipse", color, style, fill)

        # If subgraphs are used then we add both spouses here and Graphviz
        # will attempt to position both spouses closely together.
        # TODO: A person who is a parent in more than one family may only be
        #       positioned next to one of their spouses. The code currently
        #       does not take into account multiple spouses.
        if self.use_subgraphs:
            self.doc.start_subgraph(fam_id)
            f_handle = fam.get_father_handle()
            m_handle = fam.get_mother_handle()
            if f_handle:
                father = self._db.get_person_from_handle(f_handle)
                self.doc.add_link(father.get_gramps_id(),
                                  fam_id, "",
                                  self.arrowheadstyle,
                                  self.arrowtailstyle)
            if m_handle:
                mother = self._db.get_person_from_handle(m_handle)
                self.doc.add_link(mother.get_gramps_id(),
                                  fam_id, "",
                                  self.arrowheadstyle,
                                  self.arrowtailstyle)
            self.doc.end_subgraph()

    def get_gender_style(self, person):
        "return gender specific person style"
        gender = person.get_gender()
        shape = "box"
        style = "solid"
        color = ""
        fill = ""

        if gender == person.FEMALE and self.use_roundedcorners:
            style = "rounded"
        elif gender == person.UNKNOWN:
            shape = "hexagon"

        if person == self.center_person and self.increlname:
            shape = "octagon"

        if self.colorize == 'colored':
            if gender == person.MALE:
                color = self.colors['male']
            elif gender == person.FEMALE:
                color = self.colors['female']
            else:
                color = self.colors['unknown']
        elif self.colorize == 'filled':
            style += ",filled"
            if gender == person.MALE:
                fill = self.colors['male']
            elif gender == person.FEMALE:
                fill = self.colors['female']
            else:
                fill = self.colors['unknown']
        return(shape, style, color, fill)

    def get_person_label(self, person):
        "return person label string"
        # see if we have an image to use for this person
        image_path = None
        if self.use_html_output:
            media_list = person.get_media_list()
            if len(media_list) > 0:
                media_handle = media_list[0].get_reference_handle()
                media = self._db.get_media_from_handle(media_handle)
                media_mime_type = media.get_mime_type()
                if media_mime_type[0:5] == "image":
                    image_path = get_thumbnail_path(
                        media_path_full(self._db, media.get_path()),
                        rectangle=media_list[0].get_rectangle())
                    # test if thumbnail actually exists in thumbs
                    # (import of data means media files might not be present
                    image_path = find_file(image_path)

        label = ""
        line_delimiter = '\\n'

        # If we have an image, then start an HTML table; remember to close
        # the table afterwards!
        #
        # This isn't a free-form HTML format here...just a few keywords that
        # happen to be
        # similar to keywords commonly seen in HTML.  For additional
        # information on what
        # is allowed, see:
        #
        #       http://www.graphviz.org/info/shapes.html#html
        #
        if self.use_html_output and image_path:
            line_delimiter = '<BR/>'
            label += '<TABLE BORDER="0" CELLSPACING="2" CELLPADDING="0" '
            label += 'CELLBORDER="0"><TR><TD></TD><TD>'
            label += '<IMG SRC="%s"/></TD><TD></TD>' % image_path
            if self.imgpos == 0:
                #trick it into not stretching the image
                label += '</TR><TR><TD COLSPAN="3">'
            else:
                label += '<TD>'
        else:
            #no need for html label with this person
            self.use_html_output = False

        # at the very least, the label must have the person's name
        p_name = self._name_display.display(person)
        if self.use_html_output:
            # avoid < and > in the name, as this is html text
            label += p_name.replace('<', '&#60;').replace('>', '&#62;')
        else:
            label += p_name
        p_id = person.get_gramps_id()
        if self.includeid == 1: # same line
            label += " (%s)" % p_id
        elif self.includeid == 2: # own line
            label += "%s(%s)" % (line_delimiter, p_id)
        if self.event_choice != 0:
            b_date, d_date, b_place, d_place, b_type, d_type = \
                self.get_event_strings(person)
            if self.event_choice in [1, 2, 3, 4, 5] and (b_date or d_date):
                label += '%s(' % line_delimiter
                if b_date:
                    label += '%s' % b_date
                label += ' - '
                if d_date:
                    label += '%s' % d_date
                label += ')'
            if (self.event_choice in [2, 3, 5, 6] and
                    (b_place or d_place) and
                    not (self.event_choice == 3 and (b_date or d_date))
               ):
                label += '%s(' % line_delimiter
                if b_place:
                    label += '%s' % b_place
                label += ' - '
                if d_place:
                    label += '%s' % d_place
                label += ')'
        if self.event_choice == 7:
            if b_type:
                label += '%s%s' % (line_delimiter, b_type.get_abbreviation())
                if b_date:
                    label += ' %s' % b_date
                if b_place:
                    label += ' %s' % b_place

            if d_type:
                label += '%s%s' % (line_delimiter, d_type.get_abbreviation())
                if d_date:
                    label += ' %s' % d_date
                if d_place:
                    label += ' %s' % d_place

        if self.increlname and self.center_person != person:
            # display relationship info
            if self.advrelinfo:
                (relationship, _ga, _gb) = self.rel_calc.get_one_relationship(
                    self._db, self.center_person, person,
                    extra_info=True, olocale=self._locale)
                if relationship:
                    label += "%s(%s Ga=%d Gb=%d)" % (line_delimiter,
                                                     relationship, _ga, _gb)
            else:
                relationship = self.rel_calc.get_one_relationship(
                    self._db, self.center_person, person,
                    olocale=self._locale)
                if relationship:
                    label += "%s(%s)" % (line_delimiter, relationship)

        if self.occupation > 0:
            event_refs = person.get_primary_event_ref_list()
            events = [event for event in
                      [self._db.get_event_from_handle(ref.ref)
                       for ref in event_refs]
                      if event.get_type() == EventType(EventType.OCCUPATION)]
            if len(events) > 0:
                events.sort(key=lambda x: x.get_date_object())
                if self.occupation == 1:
                    occupation = events[-1].get_description()
                    if occupation:
                        label += "%s(%s)" % (line_delimiter, occupation)
                elif self.occupation == 2:
                    for evt in events:
                        date = self.get_date_string(evt)
                        place = self.get_place_string(evt)
                        desc = evt.get_description()
                        if not date and not desc and not place:
                            continue
                        label += '%s(' % line_delimiter
                        if date:
                            label += '%s' % date
                            if desc:
                                label += ' '
                        if desc:
                            label += '%s' % desc
                        if place:
                            if date or desc:
                                label += ', '
                            label += '%s' % place
                        label += ')'

        # see if we have a table that needs to be terminated
        if self.use_html_output:
            label += '</TD></TR></TABLE>'
            return label
        else:
            # non html label is enclosed by "" so escape other "
            return label.replace('"', '\\\"')

    def get_event_strings(self, person):
        "returns tuple of birth/christening and death/burying date strings"

        birth_date = birth_place = death_date = death_place = ""
        birth_type = death_type = ""

        birth_event = get_birth_or_fallback(self._db, person)
        if birth_event:
            birth_type = birth_event.type
            birth_date = self.get_date_string(birth_event)
            birth_place = self.get_place_string(birth_event)

        death_event = get_death_or_fallback(self._db, person)
        if death_event:
            death_type = death_event.type
            death_date = self.get_date_string(death_event)
            death_place = self.get_place_string(death_event)

        return (birth_date, death_date, birth_place,
                death_place, birth_type, death_type)

    def get_date_string(self, event):
        """
        return date string for an event label.

        Based on the data availability and preferences, we select one
        of the following for a given event:
            year only
            complete date
            empty string
        """
        if event and event.get_date_object() is not None:
            event_date = event.get_date_object()
            if event_date.get_year_valid():
                if self.event_choice in [4, 5]:
                    return '%i' % event_date.get_year()
                elif self.event_choice in [1, 2, 3, 7]:
                    return self._get_date(event_date)
        return ''

    def get_place_string(self, event):
        """
        return place string for an event label.

        Based on the data availability and preferences, we select one
        of the following for a given event:
            place name
            empty string
        """
        if event and self.event_choice in [2, 3, 5, 6, 7]:
            return _pd.display_event(self._db, event)
        return ''

#------------------------------------------------------------------------
#
# RelGraphOptions class
#
#------------------------------------------------------------------------
class RelGraphOptions(MenuReportOptions):
    """
    Defines options and provides handling interface.
    """
    def __init__(self, name, dbase):
        self.__pid = None
        self.__filter = None
        self.__show_relships = None
        self.__show_ga_gb = None
        self.__include_images = None
        self.__image_on_side = None
        self.__db = dbase
        self._nf = None
        self.event_choice = None
        MenuReportOptions.__init__(self, name, dbase)

    def add_menu_options(self, menu):
        ################################
        category_name = _("Report Options")
        add_option = partial(menu.add_option, category_name)
        ################################

        self.__filter = FilterOption(_("Filter"), 0)
        self.__filter.set_help(
            _("Determines what people are included in the graph"))
        add_option("filter", self.__filter)
        self.__filter.connect('value-changed', self.__filter_changed)

        self.__pid = PersonOption(_("Center Person"))
        self.__pid.set_help(_("The center person for the report"))
        menu.add_option(category_name, "pid", self.__pid)
        self.__pid.connect('value-changed', self.__update_filters)

        arrow = EnumeratedListOption(_("Arrowhead direction"), 'd')
        for i in range(0, len(_ARROWS)):
            arrow.add_item(_ARROWS[i]["value"], _ARROWS[i]["name"])
        arrow.set_help(_("Choose the direction that the arrows point."))
        add_option("arrow", arrow)

        color = EnumeratedListOption(_("Graph coloring"), 'filled')
        for i in range(0, len(_COLORS)):
            color.add_item(_COLORS[i]["value"], _COLORS[i]["name"])
        color.set_help(_("Males will be shown with blue, females "
                         "with red.  If the sex of an individual "
                         "is unknown it will be shown with gray."))
        add_option("color", color)

        # see bug report #2180
        roundedcorners = BooleanOption(_("Use rounded corners"), False)
        roundedcorners.set_help(_("Use rounded corners to differentiate "
                                  "between women and men."))
        add_option("useroundedcorners", roundedcorners)

        stdoptions.add_gramps_id_option(menu, category_name, ownline=True)

        ################################
        category_name = _("Report Options (2)")
        add_option = partial(menu.add_option, category_name)
        ################################

        self._nf = stdoptions.add_name_format_option(menu, category_name)
        self._nf.connect('value-changed', self.__update_filters)

        self.__update_filters()

        stdoptions.add_private_data_option(menu, category_name)

        stdoptions.add_living_people_option(menu, category_name)

        locale_opt = stdoptions.add_localization_option(menu, category_name)

        stdoptions.add_date_format_option(menu, category_name, locale_opt)

        ################################
        add_option = partial(menu.add_option, _("Include"))
        ################################

        self.event_choice = EnumeratedListOption(_('Dates and/or Places'), 0)
        self.event_choice.add_item(0, _('Do not include any dates or places'))
        self.event_choice.add_item(1, _('Include (birth, marriage, death) '
                                        'dates, but no places'))
        self.event_choice.add_item(2, _('Include (birth, marriage, death) '
                                        'dates, and places'))
        self.event_choice.add_item(3, _('Include (birth, marriage, death) '
                                        'dates, and places if no dates'))
        self.event_choice.add_item(4, _('Include (birth, marriage, death) '
                                        'years, but no places'))
        self.event_choice.add_item(5, _('Include (birth, marriage, death) '
                                        'years, and places'))
        self.event_choice.add_item(6, _('Include (birth, marriage, death) '
                                        'places, but no dates'))
        self.event_choice.add_item(7, _('Include (birth, marriage, death) '
                                        'dates and places on same line'))
        self.event_choice.set_help(
            _("Whether to include dates and/or places"))
        add_option("event_choice", self.event_choice)

        url = BooleanOption(_("Include URLs"), False)
        url.set_help(_("Include a URL in each graph node so "
                       "that PDF and imagemap files can be "
                       "generated that contain active links "
                       "to the files generated by the 'Narrated "
                       "Web Site' report."))
        add_option("url", url)

        self.__show_relships = BooleanOption(
            _("Include relationship to center person"), False)
        self.__show_relships.set_help(_("Whether to show every person's "
                                        "relationship to the center person"))
        add_option("increlname", self.__show_relships)
        self.__show_relships.connect('value-changed',
                                     self.__show_relships_changed)

        self.__include_images = BooleanOption(
            _('Include thumbnail images of people'), False)
        self.__include_images.set_help(
            _("Whether to include thumbnails of people."))
        add_option("includeImages", self.__include_images)
        self.__include_images.connect('value-changed', self.__image_changed)

        self.__image_on_side = EnumeratedListOption(_("Thumbnail Location"), 0)
        self.__image_on_side.add_item(0, _('Above the name'))
        self.__image_on_side.add_item(1, _('Beside the name'))
        self.__image_on_side.set_help(
            _("Where the thumbnail image should appear relative to the name"))
        add_option("imageOnTheSide", self.__image_on_side)

        #occupation = BooleanOption(_("Include occupation"), False)
        occupation = EnumeratedListOption(_('Include occupation'), 0)
        occupation.add_item(0, _('Do not include any occupation'))
        occupation.add_item(1, _('Include description '
                                 'of most recent occupation'))
        occupation.add_item(2, _('Include date, description and place '
                                 'of all occupations'))
        occupation.set_help(_("Whether to include the last occupation"))
        add_option("occupation", occupation)

        if __debug__:
            self.__show_ga_gb = BooleanOption(_("Include relationship "
                                                "debugging numbers also"),
                                              False)
            self.__show_ga_gb.set_help(_("Whether to include 'Ga' and 'Gb' "
                                         "also, to debug the relationship "
                                         "calculator"))
            add_option("advrelinfo", self.__show_ga_gb)

        ################################
        add_option = partial(menu.add_option, _("Graph Style"))
        ################################

        color_males = ColorOption(_('Males'), '#e0e0ff')
        color_males.set_help(_('The color to use to display men.'))
        add_option('colormales', color_males)

        color_females = ColorOption(_('Females'), '#ffe0e0')
        color_females.set_help(_('The color to use to display women.'))
        add_option('colorfemales', color_females)

        color_unknown = ColorOption(_('Unknown'), '#e0e0e0')
        color_unknown.set_help(
            _('The color to use when the gender is unknown.')
            )
        add_option('colorunknown', color_unknown)

        color_family = ColorOption(_('Families'), '#ffffe0')
        color_family.set_help(_('The color to use to display families.'))
        add_option('colorfamilies', color_family)

        dashed = BooleanOption(
            _("Indicate non-birth relationships with dotted lines"), True)
        dashed.set_help(_("Non-birth relationships will show up "
                          "as dotted lines in the graph."))
        add_option("dashed", dashed)

        showfamily = BooleanOption(_("Show family nodes"), True)
        showfamily.set_help(_("Families will show up as ellipses, linked "
                              "to parents and children."))
        add_option("showfamily", showfamily)

    def __update_filters(self):
        """
        Update the filter list based on the selected person
        """
        gid = self.__pid.get_value()
        person = self.__db.get_person_from_gramps_id(gid)
        nfv = self._nf.get_value()
        filter_list = utils.get_person_filters(person,
                                               include_single=False,
                                               name_format=nfv)
        self.__filter.set_filters(filter_list)

    def __filter_changed(self):
        """
        Handle filter change. If the filter is not specific to a person,
        disable the person option
        """
        if self.__show_relships and self.__show_relships.get_value():
            self.__pid.set_available(True)
        filter_value = self.__filter.get_value()
        if filter_value == 0: # "Entire Database" (as "include_single=False")
            self.__pid.set_available(False)
        else:
            # The other filters need a center person (assume custom ones too)
            self.__pid.set_available(True)

    def __image_changed(self):
        """
        Handle thumbnail change. If the image is not to be included, make the
        image location option unavailable.
        """
        self.__image_on_side.set_available(self.__include_images.get_value())

    def __show_relships_changed(self):
        """
        Enable/disable menu items if relationships are required
        """
        if self.__show_ga_gb:
            self.__show_ga_gb.set_available(self.__show_relships.get_value())
        self.__filter_changed()
